import { ref } from 'vue'
import { defineStore } from 'pinia'
import request from '@/utils/request'

// 定义匹配iam_module表结构的Module接口
// 移至文件顶部，确保正确导出和引用
interface Module {
  module_id: number  // 模块主键ID，自增长
  module_code: string  // 模块代码，唯一标识（如: user_mgmt, order_mgmt）
  module_name: string  // 模块名称，用于显示
  description?: string  // 模块详细描述
  route_path?: string  // 前端路由路径
  component_path?: string  // 前端组件路径
  icon?: string  // 模块图标标识
  parent_id: number  // 父模块ID（0表示根模块）
  level: number  // 模块层级（1:一级模块, 2:二级模块, ...）
  sort_order: number  // 模块显示排序
  is_active: boolean  // 模块是否激活(1:激活, 0:禁用)
  is_visible: boolean  // 模块是否可见(1:可见, 0:隐藏)
  created_at?: string  // 记录创建时间
  updated_at?: string  // 记录最后更新时间
  created_by?: string  // 记录创建者
  updated_by?: string  // 记录最后更新者
  is_deleted: boolean  // 软删除标志(1:已删除, 0:未删除)
}

// 定义树形结构的Module类型
interface ModuleTree extends Module {
  children?: ModuleTree[]
}

// 模拟数据
const mockModules: Module[] = [
  {
    module_id: 1,
    module_code: 'dashboard',
    module_name: '工作台',
    description: '系统首页和工作台模块',
    route_path: '/dashboard',
    component_path: 'views/dashboard/index.vue',
    icon: 'House',
    parent_id: 0,
    level: 1,
    sort_order: 1,
    is_active: true,
    is_visible: true,
    created_at: '2023-01-15T08:00:00Z',
    updated_at: '2023-10-10T14:20:00Z',
    created_by: 'system',
    updated_by: 'system',
    is_deleted: false
  },
  {
    module_id: 2,
    module_code: 'basic_data',
    module_name: '基础资料',
    description: '系统基础资料管理模块',
    route_path: '/basic-data',
    component_path: 'views/basic-data/index.vue',
    icon: 'Document',
    parent_id: 0,
    level: 1,
    sort_order: 2,
    is_active: true,
    is_visible: true,
    created_at: '2023-01-15T08:00:00Z',
    updated_at: '2023-10-10T14:20:00Z',
    created_by: 'system',
    updated_by: 'system',
    is_deleted: false
  },
  {
    module_id: 3,
    module_code: 'user_management',
    module_name: '用户管理',
    description: '系统用户管理模块',
    route_path: '/iam/user-page',
    component_path: 'views/iam/user/index.vue',
    icon: 'User',
    parent_id: 8,
    level: 2,
    sort_order: 1,
    is_active: true,
    is_visible: true,
    created_at: '2023-01-15T08:00:00Z',
    updated_at: '2023-10-10T14:20:00Z',
    created_by: 'system',
    updated_by: 'system',
    is_deleted: false
  },
  {
    module_id: 4,
    module_code: 'role_management',
    module_name: '角色管理',
    description: '系统角色管理模块',
    route_path: '/iam/role-page',
    component_path: 'views/iam/role/index.vue',
    icon: 'UserFilled',
    parent_id: 8,
    level: 2,
    sort_order: 2,
    is_active: true,
    is_visible: true,
    created_at: '2023-01-15T08:00:00Z',
    updated_at: '2023-10-10T14:20:00Z',
    created_by: 'system',
    updated_by: 'system',
    is_deleted: false
  },
  {
    module_id: 5,
    module_code: 'module_management',
    module_name: '模块管理',
    description: '系统模块管理模块',
    route_path: '/iam/module-page',
    component_path: 'views/iam/module/index.vue',
    icon: 'Menu',
    parent_id: 8,
    level: 2,
    sort_order: 3,
    is_active: true,
    is_visible: true,
    created_at: '2023-01-15T08:00:00Z',
    updated_at: '2023-10-10T14:20:00Z',
    created_by: 'system',
    updated_by: 'system',
    is_deleted: false
  },
  {
    module_id: 6,
    module_code: 'permission_management',
    module_name: '权限管理',
    description: '系统权限管理模块',
    route_path: '/iam/permission-page',
    component_path: 'views/iam/permission/index.vue',
    icon: 'Lock',
    parent_id: 8,
    level: 2,
    sort_order: 4,
    is_active: true,
    is_visible: true,
    created_at: '2023-01-15T08:00:00Z',
    updated_at: '2023-10-10T14:20:00Z',
    created_by: 'system',
    updated_by: 'system',
    is_deleted: false
  },
  {
    module_id: 7,
    module_code: 'role_auth_management',
    module_name: '角色授权',
    description: '系统角色授权管理模块',
    route_path: '/iam/role-auth-page',
    component_path: 'views/iam/role-auth/index.vue',
    icon: 'Key',
    parent_id: 8,
    level: 2,
    sort_order: 5,
    is_active: true,
    is_visible: true,
    created_at: '2023-01-15T08:00:00Z',
    updated_at: '2023-10-10T14:20:00Z',
    created_by: 'system',
    updated_by: 'system',
    is_deleted: false
  },
  {
    module_id: 8,
    module_code: 'iam_management',
    module_name: '用户与权限',
    description: '用户与权限管理主模块',
    route_path: '/iam',
    component_path: 'views/iam/index.vue',
    icon: 'Setting',
    parent_id: 0,
    level: 1,
    sort_order: 8,
    is_active: true,
    is_visible: true,
    created_at: '2023-01-15T08:00:00Z',
    updated_at: '2023-10-10T14:20:00Z',
    created_by: 'system',
    updated_by: 'system',
    is_deleted: false
  }
]

export const useIamModuleStore = defineStore('iamModule', () => {
  // 初始化时使用模拟数据
  const moduleList = ref<Module[]>(mockModules)
  const currentModule = ref<Module | null>(null)
  // 导出mockModules以便在组件中直接访问
  const mockModulesRef = ref<Module[]>(mockModules)

  const isEditing = ref(false)

  // 获取模块列表
  const fetchModuleList = async (signal?: AbortSignal) => {
    try {
      const response = await request.get('/api/iam/modules', { signal })

      // 添加类型检查，确保返回的是数组类型
      if (response && Array.isArray(response.data)) {
        moduleList.value = response.data
      } else {
        // 如果不是数组类型，使用模拟数据并打印警告
        console.warn('获取的模块列表数据类型不正确，期望数组但得到:', typeof response.data)
        // 检查是否是HTML字符串
        if (response && typeof response.data === 'string' && (response.data as string).includes('<!DOCTYPE html>')) {
          console.error('API返回了HTML文档而不是JSON数据，这可能是因为后端接口未正确配置或存在CORS问题')
        }
        // 使用模拟数据代替
        moduleList.value = [...mockModules]
      }
    } catch (error) {
      // 如果接口调用失败，继续使用模拟数据
      if ((error as Error).name !== 'AbortError') {
        console.warn('获取模块列表失败，使用模拟数据:', error)
        // 使用模拟数据
        moduleList.value = [...mockModules]
      }
    }
  }

  // 新增模块
  const addModule = async (module: Omit<Module, 'module_id' | 'created_at' | 'updated_at' | 'is_deleted'>, signal?: AbortSignal) => {
    try {
      const response = await request.post('/api/iam/modules', module, { signal })

      // 添加类型检查
      if (response && response.data) {
        moduleList.value.push(response.data)
      }
    } catch (error) {
      if ((error as Error).name !== 'AbortError') {
        console.error('新增模块失败:', error)
        // 模拟添加成功
        const newModule: Module = {
          ...module,
          module_id: Date.now(), // 使用时间戳作为临时ID
          created_at: new Date().toISOString(),
          updated_at: new Date().toISOString(),
          is_deleted: false
        }
        moduleList.value.push(newModule)
        console.log('已添加模拟模块')
      }
    }
  }

  // 编辑模块
  const updateModule = async (id: number, module: Partial<Module>, signal?: AbortSignal) => {
    try {
      const response = await request.put(`/api/iam/modules/${id}`, module, { signal })

      // 添加类型检查
      if (response && response.data) {
        const index = moduleList.value.findIndex((m) => m.module_id === id)
        if (index !== -1) {
          moduleList.value[index] = { ...moduleList.value[index], ...response.data }
        }
      }
    } catch (error) {
      if ((error as Error).name !== 'AbortError') {
        console.error('编辑模块失败:', error)
        // 模拟编辑成功
        const index = moduleList.value.findIndex((m) => m.module_id === id)
        if (index !== -1) {
          moduleList.value[index] = {
            ...moduleList.value[index],
            ...module,
            updated_at: new Date().toISOString()
          }
        }
        console.log('已更新模拟模块')
      }
    }
  }

  // 删除模块
  const deleteModule = async (id: number, signal?: AbortSignal) => {
    try {
      await request.delete(`/api/iam/modules/${id}`, { signal })
      moduleList.value = moduleList.value.filter((m) => m.module_id !== id)
      // 同时删除子模块（因为数据库有级联删除，但前端也需要同步处理）
      const deleteChildModules = (parentId: number) => {
        const childModuleIds = moduleList.value
          .filter((m) => m.parent_id === parentId)
          .map((m) => m.module_id)

        childModuleIds.forEach((childId) => {
          moduleList.value = moduleList.value.filter((m) => m.module_id !== childId)
          deleteChildModules(childId) // 递归删除子模块
        })
      }

      deleteChildModules(id) // 调用递归函数删除子模块
    } catch (error) {
      // 使用类型断言将 error 转换为 Error 类型
      if ((error as Error).name !== 'AbortError') {
        console.error('删除模块失败:', error)
        // 模拟删除成功
        moduleList.value = moduleList.value.filter((m) => m.module_id !== id)
        // 同时模拟删除子模块
        const deleteChildModules = (parentId: number) => {
          const childModuleIds = moduleList.value
            .filter((m) => m.parent_id === parentId)
            .map((m) => m.module_id)

          childModuleIds.forEach((childId) => {
            moduleList.value = moduleList.value.filter((m) => m.module_id !== childId)
            deleteChildModules(childId) // 递归删除子模块
          })
        }

        deleteChildModules(id) // 调用递归函数删除子模块
        console.log('已删除模拟模块及子模块')
      }
    }
  }

  // 设置当前编辑模块
  const setCurrentModule = (module: Module | null) => {
    currentModule.value = module
    isEditing.value = !!module
  }

  // 获取树形结构的模块列表（用于菜单展示等场景）
  const getModuleTree = () => {
    // 创建ID到模块的映射，便于快速查找
    const moduleMap = new Map<number, Module & { children?: Module[] }>()
    const rootModules: (Module & { children?: Module[] })[] = []

    // 初始化映射并找出根模块
    moduleList.value.forEach((module: Module) => {
      moduleMap.set(module.module_id, { ...module, children: [] })
      if (module.parent_id === 0) {
        rootModules.push(moduleMap.get(module.module_id)!)
      }
    })

    // 构建树形结构 - 修复语法错误
    moduleList.value.forEach((module: Module) => {
      if (module.parent_id !== 0 && moduleMap.has(module.parent_id)) {
        const parentModule = moduleMap.get(module.parent_id)!
        if (!parentModule.children) {
          parentModule.children = []
        }
        parentModule.children.push(moduleMap.get(module.module_id)!)
      }
    })

    // 按排序字段排序
    rootModules.sort((a: Module & { children?: Module[] }, b: Module & { children?: Module[] }) => {
      return a.sort_order - b.sort_order
    })

    rootModules.forEach((module: Module & { children?: Module[] }) => {
      if (module.children) {
        module.children.sort((a: Module, b: Module) => {
          return a.sort_order - b.sort_order
        })
      }
    })

    return rootModules
  }

  return {
    moduleList,
    currentModule,
    mockModules: mockModulesRef,
    isEditing,
    fetchModuleList,
    addModule,
    updateModule,
    deleteModule,
    setCurrentModule,
    getModuleTree
  }
})

// 导出接口以便在其他地方使用
export type { Module, ModuleTree }